Questions
2 of 15
1Explain the event loop.
2Explain process.next.tick()
3What could be the disadvantages of process.nextTick()
4Why use process.nextTick()?
5What is the difference between the microtask queue and the macrotask (callback) queue?
6How does Promise.then() differ from setTimeout() in terms of execution order?
7What is queueMicrotask()? How does it differ from Promise.resolve().then()?
8How does the event loop handle long-running synchronous code? What is 'blocking the event loop' and how do you avoid it in production?
9How would you profile and detect event loop lag in a production Node.js service? What tools and metrics do you use? (e.g., perf_hooks, Clinic.js, event_loop_utilization)
10How does the browser's event loop differ from Node.js's event loop?
11How do streams and backpressure in Node.js relate to the event loop? Why does improper stream handling block or overload the loop?
12What is 'starvation' in the context of the event loop? Give a real-world example.
13How do you design a CPU-intensive task (e.g., image processing, ML inference) in a Node.js app without blocking the event loop?
14How does the event loop relate to memory leaks? Can retained closures in the callback queue prevent garbage collection?
15What strategies do you use to keep the event loop healthy at scale? (offloading, chunking, job queues like BullMQ, worker threads)
nodejsnodejs
Basics
Event Loop
Buffers
Streams
Events
Time functions
Clusters
Crypto
Modules
Worker Threads
File Operations
Threads
Performance Optimisation
Websockets
02 / 15

Explain process.next.tick()

Any time we call process.nextTick() in a given phase, all callbacks passed to it will be resolved before the event loop continues. By using process.nextTick() we guarantee that the callback passed to it will always run after the current operation and before the event loop is allowed to proceed.

  1. 1

    The nextTickQueue will be processed after the current operation is completed, regardless of the current phase of the event loop.

  2. 2

    Here, an operation is defined as a transition from the underlying C/C++ handler, and handling the JavaScript that needs to be executed.

  3. 3

    To achieve this, the JS call stack is allowed to unwind and then immediately execute the provided callback which allows a person to make recursive calls to process.nextTick() without reaching a RangeError: Maximum call stack size exceeded from v8.

  4. 4

    By placing the callback in a process.nextTick(), the script still has the ability to run to completion, allowing all the variables, functions, etc., to be initialized prior to the callback being called. It also has the advantage of not allowing the event loop to continue. It may be useful for the user to be alerted to an error before the event loop is allowed to continue.

Difficulty: 6/10
Topics: event-loop, asynchronous-flow, microtasks

Scenario Questions

0-2 years experience
  1. 1

    Imagine you have a constructor function that initializes a database connection and immediately emits an 'open' event. However, the event listener registered right after calling the constructor never fires. How would you use process.nextTick to ensure the listener is registered before the event is emitted?

  2. 2

    If we have a script containing a console.log, a setTimeout with 0ms, a Promise.resolve().then(), and a process.nextTick(), can you walk me through the exact order of execution and explain why the nextTick callback runs when it does?

2-5 years experience
  1. 1

    We have a caching utility where getData(key) returns cached data synchronously if available, but fetches from a database asynchronously if not. This synchronous/asynchronous inconsistency is causing race conditions in our application flow. How would you refactor this utility using process.nextTick to guarantee the callback is always executed asynchronously?

  2. 2

    During a load test, we noticed our Node.js service became completely unresponsive to incoming HTTP requests, even though CPU usage wasn't at 100% and there were no infinite loops. We traced it to a recursive cleanup function using process.nextTick. Why did this starve the event loop, and how would you fix it?

5-8 years experience
  1. 1

    You are designing a high-throughput logging library for a microservices framework. You need to batch log messages before flushing them to disk or a remote collector. How would you leverage process.nextTick or setImmediate to implement this batching mechanism without blocking the main event loop or delaying HTTP responses?

  2. 2

    In a large-scale Express application, we are seeing memory leaks and high latency spikes under heavy load. We suspect some middleware or custom error handlers are abusing process.nextTick for deferred execution. How would you profile the event loop to identify these bottlenecks, and what architectural guidelines would you establish for the team regarding when to use process.nextTick versus setImmediate?

8+ years experience
  1. 1

    We are migrating a legacy Node.js monolith with heavy asynchronous orchestration to a modern worker-thread or microservices architecture. The legacy codebase relies heavily on process.nextTick to manage execution order across tightly coupled modules. How do you approach auditing and refactoring these execution-order dependencies to ensure predictable behavior when distributed across threads or services?

  2. 2

    Your team is building a custom, high-performance execution engine or framework on top of Node.js (like a custom test runner or a reactive stream processor). You need to define the scheduling strategy for tasks. How do you evaluate the trade-offs between native V8 microtasks (Promises), Node.js-specific process.nextTick, and macrotasks (setImmediate) regarding garbage collection, execution fairness, and backpressure?

Follow-up Questions

  • ❓What is the practical difference between process.nextTick and setImmediate in terms of the event loop phases?
  • ❓What happens to the event loop if you recursively call process.nextTick without an exit condition?
  • ❓How does queueMicrotask differ from process.nextTick in modern Node.js applications?